home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / parallax / more_exa.tar / more / sim_ann.p < prev   
Text File  |  1991-11-26  |  19KB  |  548 lines
  1. SYSTEM Chip_Placement;
  2.  
  3. (*--------------------------------------------------------------------------------*)
  4.  
  5. CONST root_n=3; n=root_n**2;
  6.       histogram_treshold = 2;
  7.  
  8. (* n : number of chips on board                                                   *)
  9. (* histogram_treshold :                                                           *)
  10. (*     max number of wires, which found place between two chips without           *)
  11. (*     overcramming the board at this place                                       *)
  12.  
  13. (*--------------------------------------------------------------------------------*)
  14.  
  15. TYPE smallset = SET OF [1..n];
  16.      feld1    = ARRAY [1..n] OF BOOLEAN;
  17.      feld2    = ARRAY [1..n] OF INTEGER;
  18.  
  19. (*--------------------------------------------------------------------------------*)
  20.  
  21. CONFIGURATION grid [root_n],[root_n];
  22.  
  23. CONNECTION sright: grid[i,j] -> grid[i  ,(j+1) MOD root_n].sleft;
  24.            sleft : grid[i,j] -> grid[i  ,(j-1) MOD root_n].sright;
  25.            sup   : grid[i,j] -> grid[(i+1) MOD root_n, j ].sdown;
  26.            sdown : grid[i,j] -> grid[(i-1) MOD root_n, j ].sup;
  27.  
  28. (* Configuration and Connection defining a two-dimensioned torus with sidelength  *)
  29. (* root_n                                                                         *)
  30.  
  31. (*--------------------------------------------------------------------------------*)
  32.  
  33. SCALAR net_table                      : ARRAY [1..n] OF feld1;
  34.        x_coord_table, y_coord_table   : ARRAY [1..n] OF feld2;
  35.        chip_nr_list                  : feld2;
  36.  
  37. (* net_table contains connections between chips                                   *)
  38. (* net_table(i,j)=TRUE  <=>  there's a connection from chip i to chip j           *)
  39. (* x_coord_table and y_coord_table contains  X- and Y-coordinates of chips        *)
  40. (* X-coordinate(Chip i)=x_coord_table[k,i]; k=1..n                                *)
  41. (* Y-coordinate(Chip j)=y_coord_table[k,i]; k=1..n                                *)
  42. (* chip_nr_list contains the assignments from chip to PE.                        *)
  43. (* Chip i is assigned to PE chip_nr_list[i]                                      *)
  44.  
  45. (*--------------------------------------------------------------------------------*)
  46.  
  47. VECTOR net_list                    : feld1;
  48.        x_coord_list, y_coord_list  : feld2; 
  49.        chip_nr                     : INTEGER;
  50.  
  51. (* These are the analogue vector-varaibles to the scalar-variables above.         *)
  52. (* They would be used for initializing vectors and exchanging datas between two   *)
  53. (* vectors                                                                        *)
  54.  
  55. (*--------------------------------------------------------------------------------*)
  56.  
  57. PROCEDURE Init;
  58.  
  59. (* initializing variables with start-values                                       *)
  60.  
  61. SCALAR net_set   : ARRAY [1..n] OF smallset;
  62.        i,j       : INTEGER;
  63.  
  64. (* The array net_set would be used only for easyer data-assignment. The net_set's *)
  65. (* would be used for building the net_table.                                      *)
  66.  
  67. VECTOR v         : INTEGER;
  68.  
  69. BEGIN
  70.   net_set[ 1]:=smallset{3,4,5,6,7,8,9};
  71.   net_set[ 2]:=smallset{1,4,5,6,7,8,9};
  72.   net_set[ 3]:=smallset{1,2,5,6,7,8,9};
  73.   net_set[ 4]:=smallset{1,2,3,6,7,8,9};
  74.   net_set[ 5]:=smallset{1,2,3,4,7,8,9};
  75.   net_set[ 6]:=smallset{1,2,3,4,5,8,9};
  76.   net_set[ 7]:=smallset{1,2,3,4,6,8,9};
  77.   net_set[ 8]:=smallset{1,2,3,4,5,7,9};
  78.   net_set[ 9]:=smallset{2,3,4,5,6,7,8};
  79. (* 
  80.   net_set[10]:=smallset{11,16};
  81.   net_set[11]:=smallset{12,17};
  82.   net_set[12]:=smallset{18};
  83.   net_set[13]:=smallset{14,19};
  84.   net_set[14]:=smallset{15,20};
  85.   net_set[15]:=smallset{16,21};
  86.   net_set[16]:=smallset{17,22};
  87.   net_set[17]:=smallset{18,23};
  88.   net_set[18]:=smallset{24};
  89.   net_set[19]:=smallset{20,25};
  90.   net_set[20]:=smallset{21,26};
  91.   net_set[21]:=smallset{22,27};
  92.   net_set[22]:=smallset{23,28};
  93.   net_set[23]:=smallset{24,29};
  94.   net_set[24]:=smallset{30};
  95.   net_set[25]:=smallset{26,31};
  96.   net_set[26]:=smallset{27,32};
  97.   net_set[27]:=smallset{28,33};
  98.   net_set[28]:=smallset{29,34};
  99.   net_set[29]:=smallset{30,35};
  100.   net_set[30]:=smallset{36};
  101.   net_set[31]:=smallset{32};
  102.   net_set[32]:=smallset{33};
  103.   net_set[33]:=smallset{34};
  104.   net_set[34]:=smallset{35};
  105.   net_set[35]:=smallset{36};
  106.   net_set[36]:=smallset{};
  107. *)
  108.  
  109. (* For wiring example one 6*6 Array of chips. Each chip has a connection to      *)
  110. (* it's right and above neighbour (if it has one)                                *)
  111.  
  112.  
  113. (* building net_table out of net_setn:                                           *)
  114.  
  115.   FOR i:=1 TO n DO
  116.     FOR j:=1 TO n DO
  117.       IF j IN net_set[i] THEN net_table[i,j]:=TRUE
  118.                            ELSE net_table[i,j]:=FALSE END;
  119.     END;
  120.   END;
  121.   LOAD(net_list,net_table);
  122.  
  123.  
  124. (* building x_coord_list and y_coord_list. The assignment is resulting from       *)
  125. (* regular construction on board                                                  *)
  126.  
  127.   PARALLEL
  128.      FOR v:=1 TO n DO
  129.        x_coord_list[v]:=(v-1) MOD root_n+1;
  130.        y_coord_list[v]:=(v-1) DIV root_n+1;
  131.      END;
  132.   ENDPARALLEL;
  133.   STORE(x_coord_list,x_coord_table); 
  134.   STORE(y_coord_list,y_coord_table);
  135.  
  136.  
  137. (* building chip_nr_list. At the beginning chip i is assigned to PE i :           *)
  138.  
  139.   FOR i:=1 TO n DO
  140.     chip_nr_list[i]:=i
  141.   END;
  142.   LOAD(chip_nr,chip_nr_list);
  143.  
  144.  
  145. END Init; 
  146.  
  147.  
  148. (*--------------------------------------------------------------------------------*)
  149.  
  150.  
  151.  
  152. PROCEDURE write_connection;
  153.  
  154. (* This procedure displays clear which chip connected to which other chip.        *)
  155.   
  156. SCALAR i,j         : INTEGER;
  157.        leere_liste : BOOLEAN;
  158. BEGIN
  159.   FOR i:=1 TO n DO
  160.     leere_liste:=TRUE;
  161.     WriteString('Chip[');WriteInt(i,1);WriteString('] is connected to: ');
  162.     FOR j:=1 TO n DO
  163.       IF net_table[i,j]=TRUE THEN leere_liste:=FALSE;
  164.                                 WriteInt(j,1);WriteString(', ') END;
  165.     END;
  166.     IF leere_liste=TRUE THEN WriteString(' nobody') END;
  167.     WriteLn;
  168.   END;
  169. END write_connection;                       
  170.  
  171.  
  172. (*--------------------------------------------------------------------------------*)
  173.   
  174.  
  175. PROCEDURE Write_coordinates;
  176.  
  177. (* This procedure displays the coordinates of the chips                           *)
  178.     
  179. SCALAR i : INTEGER;
  180. BEGIN
  181.   FOR i:=1 TO n DO
  182.     WriteString('Chip[');WriteInt(i,1);WriteString('] X-Coord.: ');
  183.     WriteInt(x_coord_table[1,i],3);
  184.     WriteString(', Y-Koord.: ');
  185.     WriteInt(y_coord_table[1,i],3);
  186.     WriteLn;
  187.   END;
  188. END Write_coordinates;
  189.  
  190. (*--------------------------------------------------------------------------------*)
  191.  
  192.  
  193. PROCEDURE Display_Chips;
  194.  
  195. (* Output of this procedure is the graphical representation of the chips.         *)
  196.  
  197. SCALAR i,j     : INTEGER;
  198.        display : ARRAY [1..root_n],[1..root_n] OF INTEGER;
  199. BEGIN
  200.   FOR i:=1 TO n DO
  201.     display[x_coord_table[1,i],y_coord_table[1,i]]:=i
  202.   END;
  203.   FOR i:=root_n TO 1 BY -1 DO
  204.     FOR j:=1 TO root_n DO
  205.       WriteInt(display[j,i],6);
  206.     END;
  207.     WriteLn;
  208.     WriteLn;
  209.   END;
  210. END Display_Chips;
  211.  
  212.  
  213. (*--------------------------------------------------------------------------------*)
  214.  
  215.  
  216. PROCEDURE exchange_chips(SCALAR i,j : INTEGER);
  217.  
  218. (* This procedure exchanges chip i with chip j .                                  *)
  219.  
  220. SCALAR k,help1, help2      : INTEGER;
  221.        help3               : BOOLEAN;
  222. BEGIN
  223.  
  224. (* exchange column i with column j in x_coord_table and y_coord_table             *)
  225.  
  226.   FOR k:=1 TO n DO
  227.     help1:=x_coord_table[k,i];
  228.     x_coord_table[k,i]:=x_coord_table[k,j];
  229.     x_coord_table[k,j]:=help1;
  230.   END;
  231.   LOAD [*],[*] (x_coord_list,x_coord_table);
  232.  
  233.   FOR k:=1 TO n DO
  234.     help1:=y_coord_table[k,i];
  235.     y_coord_table[k,i]:=y_coord_table[k,j];
  236.     y_coord_table[k,j]:=help1;
  237.   END;
  238.   LOAD [*],[*] (y_coord_list,y_coord_table);
  239.  
  240. (* find out, which PE is assigned to chip i : PE help 1,                          *)
  241. (* and which PE is assigned to chip j       : PE help 2.                          *)
  242.  
  243.   FOR k:=1 TO n DO
  244.     IF chip_nr_list[k] = i THEN help1:=k END;
  245.     IF chip_nr_list[k] = j THEN help2:=k END;
  246.   END;
  247.  
  248.  
  249. (* exchange line help1 with line help2 in net_table                               *)
  250.  
  251.   FOR k:=1 TO n DO
  252.     help3:=net_table[help1,k];
  253.     net_table[help1,k]:=net_table[help2,k];
  254.     net_table[help2,k]:=help3;
  255.   END;
  256.   LOAD(net_list,net_table);
  257.  
  258.  
  259. (* exchange entry help1 with entry help2 in chip_nr_list                          *)
  260.  
  261.   chip_nr_list[help1]:=j;
  262.   chip_nr_list[help2]:=i;
  263.   LOAD(chip_nr,chip_nr_list);
  264.  
  265. END exchange_chips;
  266.  
  267.  
  268. (*--------------------------------------------------------------------------------*)
  269.  
  270.  
  271. PROCEDURE compute_energie(): SCALAR REAL;
  272.  
  273. (* This procedure calculates the energie E=l+lambda*u                             *)
  274.  
  275.  
  276. CONST  lambda = 1.0;
  277.  
  278. (* lambda : proportionality factor.                                               *)
  279.  
  280.  
  281. SCALAR x_length, y_length             : INTEGER;
  282.        histogram_total                : INTEGER;
  283.        i,j                            : INTEGER;
  284.        up_scalar, down_scalar         : ARRAY [1..root_n],[1..root_n] OF INTEGER;
  285.        right_scalar, left_scalar      : ARRAY [1..root_n],[1..root_n] OF INTEGER;
  286.        vert_histogram, hori_histogram : ARRAY[1..root_n-1] OF INTEGER;
  287.  
  288. (*     x_length and y_length contains total X- resp. Y-Length of lands            *)
  289. (*     histogram_total correspnds to over-filling u.                              *)
  290. (*     i,j running variables.                                                     *)
  291. (*     right_scalar, left_scalar, up_scalar and down_scalar are required for      *)
  292. (*     calculating of histograms.                                                 *)
  293. (*     vert_histogram and hori_histogram contains the entrys of vertical resp.    *)
  294. (*     horizontal histograms.                                                     *)
  295.  
  296.  
  297. VECTOR x_min, x_max, y_min, y_max, x_gesamt, y_gesamt : INTEGER;
  298.        help_x, help_y                                 : INTEGER;
  299.        left, right, up, down                          : INTEGER;
  300.        v                                              : INTEGER;
  301.  
  302. (*     x_min, x_max, y_min and y_max contains the size of rectangles for          *)
  303. (*     calculating over-filling.                                                  *)
  304. (*     help_x and help_y are helping variables.                                   *)
  305. (*     left, right, up, down analogue to scalar-variables of the same name        *)
  306. (*     v is running variable.                                                     *)
  307.  
  308.  
  309. BEGIN
  310.  
  311. (* find out for each chip in Net_List this chip, which:                           *)
  312. (* - stand most distant over it      -> x_max                                     *)
  313. (* - stand most distant under it     -> x_min                                     *)
  314. (* - stand most distant left it      -> y_max                                     *)
  315. (* - stand most distant right it     -> y_min                                     *)
  316.  
  317.   
  318.   PARALLEL
  319.     x_min:=0; x_max:=0; y_min:=0; y_max:=0; help_x:=0; help_y:=0;
  320.     FOR i:=1 TO n DO
  321.       IF net_list[i] = TRUE THEN 
  322.         help_x:=x_coord_list[i]-x_coord_list[chip_nr];
  323.         help_y:=y_coord_list[i]-y_coord_list[chip_nr];
  324.         IF help_x > x_max THEN x_max:=help_x; END;
  325.         IF help_x < x_min THEN x_min:=help_x; END;
  326.         IF help_y > y_max THEN y_max:=help_y; END;
  327.         IF help_y < y_min THEN y_min:=help_y; END;
  328.       END;
  329.     END;
  330.  
  331. (*  calculating total X- resp. Y-Length of each rectangle:                      *)
  332.  
  333.     x_gesamt:=x_max-x_min;
  334.     y_gesamt:=y_max-y_min
  335.   ENDPARALLEL;
  336.  
  337. (* calculating total X- resp. Y-Length of wiring:                               *)
  338.  
  339.   x_length:=REDUCE.SUM(x_gesamt);
  340.   y_length:=REDUCE.SUM(y_gesamt);
  341.  
  342. (* x_max, x_min,.. would be assigned to right, left,.. in a way, so that        *)
  343. (* histogram-entrys can be calculated :                                         *)
  344.  
  345.   PARALLEL
  346.     left:=0; right:=0; up:=0; down:=0;
  347.     FOR v:=1 TO root_n-1 DO
  348.       IF y_max > 0 THEN up:=up+1;         y_max:=y_max-1 END;
  349.       IF y_min < 0 THEN down:=down+1;     y_min:=y_min+1 END;
  350.       IF x_max > 0 THEN right:=right+1;   x_max:=x_max-1 END;
  351.       IF x_min < 0 THEN left:=left+1;     x_min:=x_min+1 END;
  352.       PROPAGATE.sup(y_max);
  353.       PROPAGATE.sdown(y_min);
  354.       PROPAGATE.sright(x_max);
  355.       PROPAGATE.sleft(x_min);
  356.     END;
  357.   ENDPARALLEL;
  358.   STORE(up,up_scalar);
  359.   STORE(down,down_scalar);
  360.   STORE(left,left_scalar);
  361.   STORE(right,right_scalar);
  362.  
  363. (* The single histogram-entrys would be calculated out of the arrays up, down,  *)
  364. (* right and left :                                                             *)
  365.  
  366.   FOR i:=1 TO root_n-1 DO
  367.     vert_histogram[i]:=0; hori_histogram[i]:=0;
  368.     FOR j:= 1 TO root_n DO
  369.       vert_histogram[i]:=vert_histogram[i]+right_scalar[j,i]+left_scalar[j,i+1];
  370.       hori_histogram[i]:=hori_histogram[i]+down_scalar[i+1,j]+up_scalar[i,j];
  371.     END;
  372.   END;
  373.  
  374. (* The single histogram-entrys have to be summarized to a total function :      *)
  375.  
  376.   histogram_total:=0;
  377.   FOR i:=1 TO root_n-1 DO
  378.     IF vert_histogram[i] > histogram_treshold 
  379.        THEN vert_histogram[i]:=vert_histogram[i]-histogram_treshold
  380.        ELSE vert_histogram[i]:=0 END;
  381.     IF hori_histogram[i] > histogram_treshold 
  382.        THEN hori_histogram[i]:=hori_histogram[i]-histogram_treshold
  383.        ELSE hori_histogram[i]:=0 END;
  384.     histogram_total:=histogram_total+vert_histogram[i]**2+hori_histogram[i]**2;
  385.   END;
  386.   RETURN(FLOAT(x_length+y_length)+(lambda*FLOAT(histogram_total)));
  387.  
  388.  
  389. END compute_energie;
  390.  
  391. (*--------------------------------------------------------------------------------*)
  392.  
  393. PROCEDURE Annealing;
  394. CONST n_max         =  TRUNC(FLOAT(n*(n-1))*.5);
  395.       t_null        =  0.001;
  396.       delta_t       =  0.001;
  397.       c_t           =  0.98;
  398.       a_s           =  0.75;
  399.       a_k           =  0.1;
  400.       t_min         =  0.001;
  401.       max_error     =  120;
  402.  
  403. SCALAR     e_new, e_old, delta_e, e_sum, a, b  : REAL;
  404.            t                                   : REAL;
  405.            misattempt                          : INTEGER;
  406.            counter, num_accept_states          : INTEGER;
  407.            i,j                                 : INTEGER;
  408.  
  409. BEGIN
  410.  
  411.   WriteString('      M E L T I N G - P H A S E     ');
  412.   WriteLn;WriteLn;WriteLn;
  413.   WriteString('Source wiring:');
  414.   WriteLn;WriteLn;
  415.   Display_Chips;
  416.   WriteLn;WriteLn;
  417.   WriteString('Start-temperature (t_min)           = ');WriteReal(t_null,10);WriteLn;
  418.   WriteString('Temperature raising const.(delta_t) = ');WriteReal(delta_t,10);WriteLn;
  419.   WriteString('Number sequential states (n_max)    = ');WriteInt(n_max,10);WriteLn;
  420.   WriteLn;
  421.   WriteString('Start energie: ');
  422.   WriteReal(compute_energie(),10);
  423.   WriteLn;WriteLn;
  424.   t:=t_null;
  425.   e_old:=compute_energie();
  426.   REPEAT
  427.     counter:=0;
  428.     e_sum:=0.0;
  429.     t:=t+delta_t;
  430.     WriteString('New temperature: ');WriteReal(t,15);WriteLn;WriteLn;WriteLn;
  431.     num_accept_states:=0;
  432.     REPEAT
  433.       REPEAT
  434.         i:=SIRandom() MOD n +1;
  435.         j:=SIRandom() MOD n +1;
  436.       UNTIL i<>j;
  437.       counter:=counter+1;
  438.       exchange_chips(i,j);
  439.       e_new:=compute_energie();
  440.       e_sum:=e_sum+e_new;
  441.       delta_e:=e_new-e_old;
  442.       IF delta_e <= 0.0 THEN e_old:=e_new;
  443.                              num_accept_states:=num_accept_states+1 END;
  444.       IF delta_e > 0.0  THEN IF (-delta_e/t) < -700.0 THEN a:=0.0
  445.                                                       ELSE a:=Exp(-delta_e/t) END;
  446.  
  447. (* it's neccessary to check "< 700", because PARZ-Simulator generate error -     *)
  448. (* message on values less than exp(-700).                                        *)
  449.  
  450.                              b:=SRRandom();
  451.                              IF a > b THEN
  452.                                e_old:=e_new;
  453.                                num_accept_states:=num_accept_states+1;
  454.                              ELSE exchange_chips(j,i) END;
  455.                         END;
  456.     UNTIL( FLOAT(num_accept_states) >= a_s*FLOAT(n_max))  OR (counter = n_max);
  457.     WriteString('Temperature: '); WriteReal(t,10); WriteLn;  
  458.     WriteInt(num_accept_states,5);
  459.     WriteString(' States of ');
  460.     WriteInt(counter,5);
  461.     WriteString(' attempts were accepted with this temperature');WriteLn;
  462.     WriteString('Average energie: ');WriteReal(e_sum/FLOAT(counter),10);
  463.     WriteLn;
  464.     Display_Chips;
  465.     WriteLn;
  466.  
  467.  
  468.   UNTIL FLOAT(num_accept_states) >= a_s*FLOAT(n_max);
  469.  
  470.   WriteString('** Melting phase finished');
  471.   WriteLn;WriteLn;
  472.   e_old:=compute_energie();
  473.   WriteString('Chip configuration:');
  474.   WriteLn;WriteLn;
  475.   Display_Chips;
  476.   WriteLn;WriteLn;
  477.   WriteString('Temperature: ');WriteReal(t,10);
  478.   WriteString('System energie: ');WriteReal(e_old,10);
  479.   WriteLn;WriteLn;
  480. (*  WriteInt(num_accept_states,5);
  481.   WriteString(' States of ');
  482.   WriteInt(counter,5);
  483.   WriteString(' attempts were accepted with this temperature');
  484. *)
  485.   WriteLn;WriteLn;  
  486.   WriteString('      C O O L I N G - P H A S E       ');
  487.   WriteLn;WriteLn;
  488.   misattempt:=0;
  489.   REPEAT
  490.     counter:=0;
  491.     t:=t*c_t;
  492.     WriteString('New temperature: ');WriteReal(t,15);WriteLn;WriteLn;WriteLn;
  493.     num_accept_states:=0;
  494.     e_sum:=0.0;
  495.     REPEAT
  496.       REPEAT
  497.         i:=SIRandom() MOD n +1;
  498.         j:=SIRandom() MOD n +1;
  499.       UNTIL i<>j;
  500.       exchange_chips(i,j);
  501.       counter:=counter+1;
  502.       e_new:=compute_energie();
  503.       e_sum:=e_sum+e_new;
  504.       delta_e:=e_new-e_old;
  505.  
  506.       IF delta_e <= 0.0 THEN e_old:=e_new;
  507.                              num_accept_states:=num_accept_states+1 END;
  508.       IF delta_e > 0.0  THEN   IF (-delta_e/t) < -700.0 THEN a:=0.0
  509.                                                         ELSE a:=Exp(-delta_e/t) END;
  510. (* it's neccessary to check "< 700", because PARZ-Simulator generate error -     *)
  511. (* message on values less than exp(-700).                                        *)
  512.  
  513.                                b:=SRRandom();
  514.                                IF a > b THEN
  515.                                  e_old:=e_new;
  516.                                  num_accept_states:=num_accept_states+1;
  517.                                ELSE exchange_chips(j,i) END;
  518.                          END;
  519.     UNTIL( FLOAT(num_accept_states) >= a_k*FLOAT(n_max))  OR (counter = n_max);
  520.     IF FLOAT(num_accept_states) <= a_k*FLOAT(n) THEN misattempt:=misattempt+1
  521.                                            ELSE misattempt:=0 END;
  522. (* 
  523.     WriteString('Temperature: '); WriteReal(t,10); WriteLn;  
  524.     WriteInt(num_accept_states,5);
  525.     WriteString(' States of ');
  526.     WriteInt(counter,5);
  527.     WriteString(' attempts were accepted with this temperature');WriteLn;
  528.     WriteString('Average energie: ');WriteReal(e_sum/FLOAT(counter),10);
  529.     WriteLn;
  530.     Display_Chips;
  531.     WriteLn;
  532. *)
  533.   UNTIL (t < t_min) OR (misattempt > max_error) OR (num_accept_states = 0);
  534.     WriteString('** Coolong phase finished');
  535.     WriteString('Minimized wiring:');WriteLn;
  536.     Display_Chips; WriteLn;
  537.     WriteString('System energie: ');WriteReal(e_old,10);WriteLn;
  538. END Annealing;
  539.  
  540.  
  541. BEGIN
  542.   WriteString('SIMULATION REPORT');WriteLn;WriteLn;
  543.   Init;
  544.   write_connection;
  545.   Write_coordinates;
  546.   Annealing;
  547. END Chip_Placement.
  548.